/* Copyright (C) 2005-2013 Free Software Foundation, Inc.
   Contributed by Richard Henderson <rth@redhat.com>.

   This file is part of the GNU OpenMP Library (libgomp).

   Libgomp is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details.

   Under Section 7 of GPL version 3, you are granted additional
   permissions described in the GCC Runtime Library Exception, version
   3.1, as published by the Free Software Foundation.

   You should have received a copy of the GNU General Public License and
   a copy of the GCC Runtime Library Exception along with this program;
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
   <http://www.gnu.org/licenses/>.  */

/* This file handles the (bare) PARALLEL construct.  */

#include "libgomp.h"
#include <limits.h>
#include "ompt-specific.h"

/* Determine the number of threads to be launched for a PARALLEL construct.
   This algorithm is explicitly described in OpenMP 3.0 section 2.4.1.
   SPECIFIED is a combination of the NUM_THREADS clause and the IF clause.
   If the IF clause is false, SPECIFIED is forced to 1.  When NUM_THREADS
   is not present, SPECIFIED is 0.  */

unsigned
gomp_resolve_num_threads (unsigned specified, unsigned count)
{
  struct gomp_thread *thread = gomp_thread();
  struct gomp_task_icv *icv;
  unsigned threads_requested, max_num_threads, num_threads;
  unsigned long remaining;

  icv = gomp_icv (false);

  if (specified == 1)
    return 1;
  else if (thread->ts.active_level >= 1 && !icv->nest_var)
    return 1;
  else if (thread->ts.active_level >= gomp_max_active_levels_var)
    return 1;

  /* If NUM_THREADS not specified, use nthreads_var.  */
  if (specified == 0)
    threads_requested = icv->nthreads_var;
  else
    threads_requested = specified;

  max_num_threads = threads_requested;

  /* If dynamic threads are enabled, bound the number of threads
     that we launch.  */
  if (icv->dyn_var)
    {
      unsigned dyn = gomp_dynamic_max_threads ();
      if (dyn < max_num_threads)
	max_num_threads = dyn;

      /* Optimization for parallel sections.  */
      if (count && count < max_num_threads)
	max_num_threads = count;
    }

  /* ULONG_MAX stands for infinity.  */
  if (__builtin_expect (gomp_thread_limit_var == ULONG_MAX, 1)
      || max_num_threads == 1)
    return max_num_threads;

#ifdef HAVE_SYNC_BUILTINS
  do
    {
      remaining = gomp_remaining_threads_count;
      num_threads = max_num_threads;
      if (num_threads > remaining)
	num_threads = remaining + 1;
    }
  while (__sync_val_compare_and_swap (&gomp_remaining_threads_count,
				      remaining, remaining - num_threads + 1)
	 != remaining);
#else
  gomp_mutex_lock (&gomp_remaining_threads_lock);
  num_threads = max_num_threads;
  remaining = gomp_remaining_threads_count;
  if (num_threads > remaining)
    num_threads = remaining + 1;
  gomp_remaining_threads_count -= num_threads - 1;
  gomp_mutex_unlock (&gomp_remaining_threads_lock);
#endif

  return num_threads;
}

#include <stdio.h>
void
GOMP_parallel_start (void (*fn) (void *), void *data, unsigned num_threads)
{
//  void *reenter_runtime_frame =  __builtin_frame_address(0);
  num_threads = gomp_resolve_num_threads (num_threads, 0);

#if OMPT_SUPPORT
    static int ompt_initialized = 0;
    if (!ompt_initialized) {
        ompt_initialized = 1;
	ompt_init();
    }

    ompt_parallel_id_t ompt_parallel_id = 0;
    ompt_task_id_t ompt_task_id = 0;
    ompt_frame_t  *ompt_frame;
    //calling gomp_thread should be ok as it gets inlined but it is not clear if pthread_specific
    //gets inlined too
    struct gomp_thread *master_th  = gomp_thread(); 
    if (ompt_status & ompt_status_track) {
      ompt_parallel_id = __ompt_parallel_id_new(0);
      ompt_task_id = __ompt_get_task_id_internal(0);
      ompt_frame = __ompt_get_task_frame_internal(0);
      master_th->ompt_thread_info.state = ompt_state_work_parallel;
      if ((ompt_status == ompt_status_track_callback) &&
          ompt_callbacks.ompt_callback(ompt_event_parallel_begin)) {
          ompt_callbacks.ompt_callback(ompt_event_parallel_begin)
          (ompt_task_id, ompt_frame, ompt_parallel_id, (void *) NULL);
      }
    }
#endif

  gomp_team_start (fn, data, num_threads, gomp_new_team (num_threads));

#if OMPT_SUPPORT
    if (omp_get_thread_num() == 0) {
        master_th->ts.team->ompt_team_info.parallel_id = ompt_parallel_id; 
	master_th->task->ompt_task_info.task_id= ompt_task_id;
	ompt_frame =  __ompt_get_task_frame_internal(0); 
	if(ompt_frame) master_th->task->ompt_task_info.frame = *ompt_frame;
    	//Mark this frame as start of runtime
    	//FIXME: Marking this frame as entry is disabling assembling in hpctoolkit. Why?
    	//master_th->task->ompt_task_info.frame.reenter_runtime_frame =  reenter_runtime_frame;
      
    }
#endif
}

void
GOMP_parallel_end (void)
{
  if (__builtin_expect (gomp_thread_limit_var != ULONG_MAX, 0))
    {
      struct gomp_thread *thr = gomp_thread ();
      struct gomp_team *team = thr->ts.team;
      unsigned int nthreads = team ? team->nthreads : 1;
      gomp_team_end ();
      if (nthreads > 1)
	{
#ifdef HAVE_SYNC_BUILTINS
	  __sync_fetch_and_add (&gomp_remaining_threads_count,
				nthreads - 1);
#else
	  gomp_mutex_lock (&gomp_remaining_threads_lock);
	  gomp_remaining_threads_count += nthreads - 1;
	  gomp_mutex_unlock (&gomp_remaining_threads_lock);
#endif
	}
    }
  else {
#if OMPT_SUPPORT
	    volatile ompt_parallel_id_t ompt_parallel_id;
	    ompt_task_id_t ompt_task_id;
	    ompt_frame_t  *ompt_frame;
	    struct gomp_thread *master_th = gomp_thread(); 
            if (ompt_status & ompt_status_track) {
      		ompt_parallel_id = master_th->ts.team->ompt_team_info.parallel_id;
		ompt_task_id = master_th->task->ompt_task_info.task_id;
		ompt_frame = &(master_th->task->ompt_task_info.frame);
   		if ((ompt_status == ompt_status_track_callback) &&
                  ompt_callbacks.ompt_callback(ompt_event_parallel_end)) {

                  ompt_callbacks.ompt_callback(ompt_event_parallel_end)
                  (ompt_task_id,ompt_frame, ompt_parallel_id,(void *) NULL);

              }
              master_th->ompt_thread_info.state = ompt_state_overhead;
      	     //master_th->task->ompt_task_info.frame.exit_runtime_frame =  __builtin_frame_address(0);
            }
#endif

    gomp_team_end ();
  }
}


/* The public OpenMP API for thread and team related inquiries.  */

int
omp_get_num_threads (void)
{
  struct gomp_team *team = gomp_thread ()->ts.team;
  return team ? team->nthreads : 1;
}

int
omp_get_thread_num (void)
{
  return gomp_thread ()->ts.team_id;
}

/* This wasn't right for OpenMP 2.5.  Active region used to be non-zero
   when the IF clause doesn't evaluate to false, starting with OpenMP 3.0
   it is non-zero with more than one thread in the team.  */

int
omp_in_parallel (void)
{
  return gomp_thread ()->ts.active_level > 0;
}

int
omp_get_level (void)
{
  return gomp_thread ()->ts.level;
}

int
omp_get_ancestor_thread_num (int level)
{
  struct gomp_team_state *ts = &gomp_thread ()->ts;
  if (level < 0 || level > ts->level)
    return -1;
  for (level = ts->level - level; level > 0; --level)
    ts = &ts->team->prev_ts;
  return ts->team_id;
}

int
omp_get_team_size (int level)
{
  struct gomp_team_state *ts = &gomp_thread ()->ts;
  if (level < 0 || level > ts->level)
    return -1;
  for (level = ts->level - level; level > 0; --level)
    ts = &ts->team->prev_ts;
  if (ts->team == NULL)
    return 1;
  else
    return ts->team->nthreads;
}

int
omp_get_active_level (void)
{
  return gomp_thread ()->ts.active_level;
}

ialias (omp_get_num_threads)
ialias (omp_get_thread_num)
ialias (omp_in_parallel)
ialias (omp_get_level)
ialias (omp_get_ancestor_thread_num)
ialias (omp_get_team_size)
ialias (omp_get_active_level)
